package controllers

import (
	"encoding/json"
	"strconv"
	"supershare/backend/middleware"
	"supershare/backend/models"

	"github.com/beego/beego/v2/server/web"
)

// RoleController 角色管理控制器
type RoleController struct {
	web.Controller
}

// RoleListRequest 角色列表请求参数
type RoleListRequest struct {
	Page        int    `json:"page" form:"page"`
	PageSize    int    `json:"pageSize" form:"pageSize"`
	Name        string `json:"name" form:"name"`
	Status      int8   `json:"status" form:"status"`
	FranchiseId int64  `json:"franchise_id" form:"franchise_id"`
}

// RoleCreateRequest 创建角色请求参数
type RoleCreateRequest struct {
	Name        string  `json:"name"`
	Description string  `json:"description"`
	Status      int8    `json:"status"`
	FranchiseId int64   `json:"franchise_id"`
	Permissions []int64 `json:"permissions"`
}

// RoleUpdateRequest 更新角色请求参数
type RoleUpdateRequest struct {
	Name        string  `json:"name"`
	Description string  `json:"description"`
	Status      int8    `json:"status"`
	Permissions []int64 `json:"permissions"`
}

// List 获取角色列表
func (c *RoleController) List() {
	// 获取请求参数
	page, _ := strconv.Atoi(c.GetString("page"))
	if page <= 0 {
		page = 1
	}

	pageSize, _ := strconv.Atoi(c.GetString("pageSize"))
	if pageSize <= 0 || pageSize > 100 {
		pageSize = 10
	}

	name := c.GetString("name")
	status, _ := c.GetInt8("status", -1)
	franchiseId, _ := c.GetInt64("franchise_id", -1)

	// 获取当前管理员信息
	admin, err := middleware.GetCurrentAdmin(c.Ctx)
	if err != nil || admin == nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "未授权访问",
		}
		c.ServeJSON()
		return
	}

	// 非总管理员只能查看自己加盟商的角色
	if admin.FranchiseId != 0 {
		franchiseId = admin.FranchiseId
	}

	// 构建过滤条件
	filters := make(map[string]interface{})
	if name != "" {
		filters["name"] = name
	}
	if status >= 0 {
		filters["status"] = int8(status)
	}
	if franchiseId > 0 {
		filters["franchise_id"] = franchiseId
	}

	// 查询角色列表
	roles, total, err := models.GetRoleList(page, pageSize, filters)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "获取角色列表失败",
		}
		c.ServeJSON()
		return
	}

	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "获取角色列表成功",
		"data": map[string]interface{}{
			"list":  roles,
			"total": total,
			"page":  page,
			"size":  pageSize,
		},
	}
	c.ServeJSON()
}

// Create 创建角色
func (c *RoleController) Create() {
	// 解析请求参数
	var req RoleCreateRequest
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的请求参数",
		}
		c.ServeJSON()
		return
	}

	// 获取当前管理员信息
	admin, err := middleware.GetCurrentAdmin(c.Ctx)
	if err != nil || admin == nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "未授权访问",
		}
		c.ServeJSON()
		return
	}

	// 创建角色
	role := &models.Role{
		Name:        req.Name,
		Description: req.Description,
		Status:      req.Status,
	}
	// 非总管理员只能创建自己加盟商的角色
	if admin.FranchiseId != 0 {
		req.FranchiseId = admin.FranchiseId
	}

	id, err := models.CreateRole(role)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "创建角色失败",
		}
		c.ServeJSON()
		return
	}

	// 分配权限
	if len(req.Permissions) > 0 {
		err = models.AddPermissionsToRole(id, req.Permissions)
		if err != nil {
			c.Data["json"] = map[string]interface{}{
				"success": false,
				"message": "分配权限失败",
			}
			c.ServeJSON()
			return
		}
	}

	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "创建角色成功",
		"data":    id,
	}
	c.ServeJSON()
}

// Update 更新角色
func (c *RoleController) Update() {
	// 获取角色ID
	id, _ := strconv.ParseInt(c.Ctx.Input.Param(":id"), 10, 64)
	if id <= 0 {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的角色ID",
		}
		c.ServeJSON()
		return
	}

	// 解析请求参数
	var req RoleUpdateRequest
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的请求参数",
		}
		c.ServeJSON()
		return
	}

	// 获取当前管理员信息
	admin, err := middleware.GetCurrentAdmin(c.Ctx)
	if err != nil || admin == nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "未授权访问",
		}
		c.ServeJSON()
		return
	}

	// 获取角色信息
	role, err := models.GetRoleById(id)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "角色不存在",
		}
		c.ServeJSON()
		return
	}

	// 非总管理员只能更新自己加盟商的角色
	if admin.FranchiseId != 0 && role.FranchiseId != admin.FranchiseId {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无权操作该角色",
		}
		c.ServeJSON()
		return
	}

	// 更新角色信息
	role.Name = req.Name
	role.Description = req.Description
	role.Status = req.Status

	err = models.UpdateRole(role, "Name", "Description", "Status")
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "更新角色失败",
		}
		c.ServeJSON()
		return
	}

	// 更新权限
	if len(req.Permissions) > 0 {
		err = models.AddPermissionsToRole(id, req.Permissions)
		if err != nil {
			c.Data["json"] = map[string]interface{}{
				"success": false,
				"message": "更新权限失败",
			}
			c.ServeJSON()
			return
		}
	}

	// 清除相关管理员的权限缓存
	models.ClearAllPermissionCache()

	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "更新角色成功",
	}
	c.ServeJSON()
}

// Delete 删除角色
func (c *RoleController) Delete() {
	// 获取角色ID
	id, _ := strconv.ParseInt(c.Ctx.Input.Param(":id"), 10, 64)
	if id <= 0 {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的角色ID",
		}
		c.ServeJSON()
		return
	}

	// 获取当前管理员信息
	admin, err := middleware.GetCurrentAdmin(c.Ctx)
	if err != nil || admin == nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "未授权访问",
		}
		c.ServeJSON()
		return
	}

	// 获取角色信息
	role, err := models.GetRoleById(id)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "角色不存在",
		}
		c.ServeJSON()
		return
	}

	// 非总管理员只能删除自己加盟商的角色
	if admin.FranchiseId != 0 && role.FranchiseId != admin.FranchiseId {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无权操作该角色",
		}
		c.ServeJSON()
		return
	}

	// 删除角色
	err = models.DeleteRole(id)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "删除角色失败",
		}
		c.ServeJSON()
		return
	}

	// 清除相关管理员的权限缓存
	models.ClearAllPermissionCache()

	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "删除角色成功",
	}
	c.ServeJSON()
}

// GetRolePermissions 获取角色拥有的权限列表
func (c *RoleController) GetRolePermissions() {
	// 获取角色ID
	id, _ := strconv.ParseInt(c.Ctx.Input.Param(":id"), 10, 64)
	if id <= 0 {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的角色ID",
		}
		c.ServeJSON()
		return
	}

	// 获取当前管理员信息
	admin, err := middleware.GetCurrentAdmin(c.Ctx)
	if err != nil || admin == nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "未授权访问",
		}
		c.ServeJSON()
		return
	}

	// 获取角色信息
	role, err := models.GetRoleById(id)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "角色不存在",
		}
		c.ServeJSON()
		return
	}

	// 非总管理员只能查看自己加盟商的角色权限
	if admin.FranchiseId != 0 && role.FranchiseId != admin.FranchiseId {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无权操作该角色",
		}
		c.ServeJSON()
		return
	}

	// 获取角色权限
	permissions, err := models.GetPermissionsIdByRoleId(id)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "获取角色权限失败",
		}
		c.ServeJSON()
		return
	}

	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "获取角色权限成功",
		"data":    permissions,
	}
	c.ServeJSON()
}

// UpdateRolePermissions 更新角色拥有的权限列表
func (c *RoleController) UpdateRolePermissions() {
	// 获取角色ID
	id, _ := strconv.ParseInt(c.Ctx.Input.Param(":id"), 10, 64)
	if id <= 0 {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的角色ID",
		}
		c.ServeJSON()
		return
	}

	// 获取当前管理员信息
	admin, err := middleware.GetCurrentAdmin(c.Ctx)
	if err != nil || admin == nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "未授权访问",
		}
		c.ServeJSON()
		return
	}

	// 获取角色信息
	role, err := models.GetRoleById(id)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "角色不存在",
		}
		c.ServeJSON()
		return
	}

	// 非总管理员只能更新自己加盟商的角色权限
	if admin.FranchiseId != 0 && role.FranchiseId != admin.FranchiseId {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无权操作该角色",
		}
		c.ServeJSON()
		return
	}
	// 解析请求参数
	var req RoleUpdateRequest
	err = json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的请求参数",
		}
		c.ServeJSON()
		return
	}
	//删除原有的角色权限
	err = models.DeleteRolePermissions(id)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "更新角色权限失败",
		}
		c.ServeJSON()
		return
	}
	//更新角色权限
	err = models.AddPermissionsToRole(id, req.Permissions)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "更新角色权限失败",
		}
		c.ServeJSON()
		return
	}
	// 清除相关管理员的权限缓存
	models.ClearAllPermissionCache()
	// 返回结果
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "更新角色权限成功",
	}
	c.ServeJSON()
}
